package 作业.抽奖箱半成品板;

import java.util.*;

public class FrameworkLotteryTest {
    public static void main(String[] args) {
        // TODO: 定义奖池中的奖项 {10,5,20,50,100,200,500,800,2,80,300,700}
        // 你需要在这里创建一个int数组存储上述奖项
        int[] prizes = {10, 5, 20, 50, 100, 200, 500, 800, 2, 80, 300, 700}; // 这行已经帮你完成

        // TODO: 创建共享的抽奖池对象
        // 你需要创建一个实现了Runnable接口的对象
        SimplePrizePool prizePool = new SimplePrizePool(prizes); // 这行已经帮你完成

        // TODO: 创建两个线程代表两个抽奖箱，分别命名为"抽奖箱1"和"抽奖箱2"
        // 提示: 使用 new Thread(Runnable target, String name) 构造方法
        Thread box1 = new Thread(prizePool, "抽奖箱1"); // 这行已经帮你完成
        Thread box2 = new Thread(prizePool, "抽奖箱2"); // 这行已经帮你完成

        // TODO: 启动两个线程
        // 提示: 使用 Thread 对象的 start() 方法
        box1.start(); // 这行已经帮你完成
        box2.start(); // 这行已经帮你完成
    }
}

// TODO: 实现Runnable接口的抽奖池类
class SimplePrizePool implements Runnable {
    // TODO: 定义必要的成员变量
    // 你需要定义以下变量:
    // 1. 存储奖池数组的变量
    // 2. 标记奖项是否已被抽取的数组
    // 3. 随机数生成器
    // 4. 两个List分别记录两个抽奖箱的奖项
    private int[] prizes;
    private boolean[] taken;
    private Random random = new Random();
    private List<Integer> box1Prizes = new ArrayList<>();
    private List<Integer> box2Prizes = new ArrayList<>();

    // TODO: 实现构造方法
    // 提示: 初始化奖池数组和taken数组
    public SimplePrizePool(int[] prizes) {
        this.prizes = prizes;
        this.taken = new boolean[prizes.length];
    }

    @Override
    public void run() {
        // TODO: 实现抽奖逻辑
        // 每个线程需要抽取6个不重复的奖项
        
        // 用于存储当前线程抽取的所有奖项
        List<Integer> currentPrizes = new ArrayList<>();
        
        // 每个线程抽取6个奖项
        for (int i = 0; i < 6; i++) {
            // TODO: 线程安全地抽取一个奖项
            // 提示: 使用synchronized关键字保证线程安全
            
            // 随机抽取一个未被抽取的奖项
            int index;
            synchronized (this) {
                // 循环直到找到一个未被抽取的奖项
                do {
                    // TODO: 生成一个随机索引
                    index = random.nextInt(prizes.length);
                } while (taken[index]); // 如果该奖项已被抽取，则重新选择
                
                // 标记该奖项已被抽取
                taken[index] = true;
            }
            
            // 获取奖项金额
            int prize = prizes[index];
            
            // 添加到当前线程的奖项列表中
            currentPrizes.add(prize);
            
            // TODO: 实现需求1 - 每次抽取一个奖项就打印
            // 格式: "抽奖箱X 又产生了一个 Y 元大奖"
            System.out.println(Thread.currentThread().getName() + " 又产生了一个 " + prize + " 元大奖");
            
            // 添加短暂延迟，让输出更清晰
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        
        // TODO: 实现需求2和3 - 抽完后打印统计信息
        // 提示: 在同步块中完成，确保线程安全
        synchronized (this) {
            // 根据线程名称确定是哪个抽奖箱
            if (Thread.currentThread().getName().equals("抽奖箱1")) {
                box1Prizes.addAll(currentPrizes);
            } else {
                box2Prizes.addAll(currentPrizes);
            }
            
            // 当两个抽奖箱都完成抽奖后，输出统计信息
            if (box1Prizes.size() == 6 && box2Prizes.size() == 6) {
                // TODO: 打印抽奖箱1的统计信息
                // 格式: "在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：x,x,x,x,x,x最高奖项为xxx元，总计额为xxx元"
                System.out.println("在此次抽奖过程中，抽奖箱1总共产生了6个奖项，分别为：" 
                    + formatPrizes(box1Prizes) 
                    + "最高奖项为" + Collections.max(box1Prizes) + "元，总计额为" 
                    + calculateSum(box1Prizes) + "元");
                
                // TODO: 打印抽奖箱2的统计信息
                System.out.println("在此次抽奖过程中，抽奖箱2总共产生了6个奖项，分别为：" 
                    + formatPrizes(box2Prizes) 
                    + "最高奖项为" + Collections.max(box2Prizes) + "元，总计额为" 
                    + calculateSum(box2Prizes) + "元");
                
                // TODO: 实现需求3 - 比较哪个抽奖箱产生了最大奖项
                // 格式: "在此次抽奖过程中,抽奖箱X中产生了最大奖项,该奖项金额为xxx元"
                int maxPrize1 = Collections.max(box1Prizes);
                int maxPrize2 = Collections.max(box2Prizes);
                
                if (maxPrize1 > maxPrize2) {
                    System.out.println("在此次抽奖过程中,抽奖箱1中产生了最大奖项,该奖项金额为" + maxPrize1 + "元");
                } else if (maxPrize2 > maxPrize1) {
                    System.out.println("在此次抽奖过程中,抽奖箱2中产生了最大奖项,该奖项金额为" + maxPrize2 + "元");
                } else {
                    System.out.println("在此次抽奖过程中,两个抽奖箱都产生了最大奖项,该奖项金额为" + maxPrize1 + "元");
                }
            }
        }
    }
    
    // TODO: 辅助方法 - 格式化奖项列表
    // 提示: 将List中的奖项格式化为字符串，以逗号分隔
    private String formatPrizes(List<Integer> prizes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < prizes.size(); i++) {
            sb.append(prizes.get(i));
            if (i < prizes.size() - 1) {
                sb.append(",");
            }
        }
        sb.append("最高奖项为");
        return sb.toString();
    }
    
    // TODO: 辅助方法 - 计算奖项总和
    // 提示: 遍历List计算所有奖项的总和
    private int calculateSum(List<Integer> prizes) {
        int sum = 0;
        for (int prize : prizes) {
            sum += prize;
        }
        return sum;
    }
}